home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / arith / iio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  3.7 KB  |  245 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  iio.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. /*    iio.c,        RD, 20.02.90 */
  17.  
  18. #include <LEDA/impl/iint.h>
  19. #include <LEDA/impl/iloc.h>
  20. #include <stdio.h>
  21. #include <ctype.h>
  22.  
  23. int fscanI(fp, a)
  24.     FILE *fp;
  25.     pInteger a;
  26. {    register int c, count;
  27.     int sign=PLUS;
  28.     Integer help;
  29.  
  30.     cI(&help);
  31.     count=0;
  32.     do {
  33.         c=getc(fp);
  34.         count++;
  35.     } while (isspace(c));
  36.     if (c=='-') {
  37.         sign=MINUS;
  38.         c=getc(fp);
  39.         count++;
  40.     } else if (c=='+') {
  41.         c=getc(fp);
  42.         count++;
  43.     }
  44.     while (c=='0') {
  45.         c=getc(fp);
  46.         count++;
  47.     }
  48.     Iasint(a, 0);
  49.     while (isdigit(c)) {
  50.         ImuasP(a, 10);
  51.         Iasint(&help, c-'0');
  52.         IplasI(a, &help);
  53.         c=getc(fp);
  54.         count++;
  55.     }
  56.     ungetc(c, fp);
  57.     count--;
  58.     if (!Ieq0(a))
  59.         a->sign=sign;
  60.     dI(&help);
  61.     return count;
  62. }        /* fscanI */
  63.  
  64. int fprintI(fp, a)
  65.     FILE *fp;
  66.     const Integer *a;
  67. {    char *s;
  68.     int i, sl, count=0;
  69.     Integer help;
  70.  
  71.     sl=Ilog(a);
  72.     sl=sl/3+2;
  73.     s=(char*)Imalloc(sl*sizeof(char));
  74.     if (!s)
  75.         Ierror("fprintI: no memory available\n");
  76. #ifdef USE_DIRECT_OUTPUT_CONVERSION
  77.     if (sl==-1) {
  78.         putc('0', fp);
  79.         count++;
  80.         return count;
  81.     }
  82.     if (Ilt0(a)) {
  83.         putc('-', fp);
  84.         count++;
  85.     }
  86.     cIasI(&help, a);
  87.     i=0;
  88.     while (!Ieq0(&help)) {
  89.         s[i]='0'+uIdiasP(&help, 10);
  90.         i++;
  91.     }
  92.     dI(&help);
  93.     i--;
  94.     for (; i>=0; i--) {
  95.         putc(s[i], fp);
  96.         count++;
  97.     }
  98. #else
  99.     count=Itoa(a, s);
  100.     for ( i=0; i<count; i++ )
  101.         putc(s[i], fp);
  102. #endif
  103.     Ifree(s);
  104.     return count;
  105. }        /* fprintI */
  106.  
  107. /******************************************/
  108.  
  109. char * wIdata1(a, l)
  110.     const Integer * a;
  111.     int * l;
  112. {    *l=sizeof(int) + sizeof(int);
  113.     return (char *) (& a->length);
  114. }
  115.  
  116. char * wIdata2(a, l)
  117.     const Integer * a;
  118.     int * l;
  119. {    *l=a->length * sizeof(PLACE);
  120.     return (char *) a->vec;
  121. }
  122.  
  123. char * rIdata1(a, l)
  124.     const Integer * a;
  125.     int * l;
  126. {    *l=sizeof(int) + sizeof(int);
  127.     return (char *) (& a->length);
  128. }
  129.  
  130. char * rIdata2(a, l)
  131.     Integer * a;
  132.     int * l;
  133. {    int nl=a->length;
  134.     if (nl > a->maxlength) {
  135.         delvec(a->vec, a->maxlength);
  136.         a->maxlength=nl;
  137.         a->vec=newvec(&a->maxlength);
  138.     }
  139.     *l=nl * sizeof(PLACE);
  140.     return (char *) a->vec;
  141. }
  142.  
  143. /************************************/
  144.  
  145. #if HALFRADIX > 1000000000
  146. #define DECCONV 1000000000
  147. #define NCONV    9
  148. #else
  149. #define DECCONV 10000
  150. #define NCONV    4
  151. #endif
  152.  
  153. int Itoa(n, s)
  154.     const Integer *n;
  155.     char s[];
  156. {    int count=0;
  157.     Integer help;
  158.     char *p, *q, c;
  159.  
  160.     if (Ieq0(n)) {
  161.         s[count]='0';
  162.         count++;
  163.         s[count]='\0';
  164.         return count;
  165.     }
  166.     if (Ilt0(n)) {
  167.         s[count]='-';
  168.         count++;
  169.     }
  170.     cIasI(&help, n);
  171.     while (!Ieq0(&help)) {
  172.         int rem=uIdiasP(&help, DECCONV);
  173.         if (Ieq0(&help)) {    /* skip leading 0 */
  174.             while ( rem ) {
  175.                 s[count]='0'+ rem % 10;
  176.                 count++;
  177.                 rem /= 10;
  178.             }
  179.         } else {        /* print leading 0 */
  180.             int i;
  181.             for (i=0; i<NCONV; i++) {
  182.                 s[count]='0'+ rem % 10; 
  183.                 count++; 
  184.                 rem /= 10; 
  185.             }   
  186.         }
  187.     }
  188.     dI(&help);
  189.     /* Vertausche Stringeintraege, damit hoeherwertige Stellen
  190.         vorne stehen.
  191.     */
  192.     if (Ilt0(n))
  193.         p=&s[1];
  194.     else
  195.         p=&s[0];
  196.     q=&s[count-1];
  197.     while (p<q) {
  198.         c=*p;
  199.         *p++=*q;
  200.         *q--=c;
  201.     }
  202.     s[count]='\0';
  203.     return count;
  204. }        /* Itoa */
  205.  
  206. int atoI(s, n)
  207.     char s[];
  208.     Integer *n;
  209. {    register int c, count;
  210.     Integer help;
  211.     int sign=PLUS;
  212.  
  213.     cI(&help);
  214.     count=0;
  215.     do {
  216.         c=s[count];
  217.         count++;
  218.     } while (isspace(c));
  219.     if (c=='-') {
  220.         sign=MINUS;
  221.         c=s[count];
  222.         count++;
  223.     } else if (c=='+') {
  224.         c=s[count];
  225.         count++;
  226.     }
  227.     while (c=='0') {
  228.         c=s[count];
  229.         count++;
  230.     }
  231.     Iasint(n, 0);
  232.     while (isdigit(c)) {
  233.         ImuasP(n, 10);
  234.         Iasint(&help, c-'0');
  235.         IplasI(n, &help);
  236.         c=s[count];
  237.         count++;
  238.     }
  239.     count--;
  240.     if (!Ieq0(n))
  241.         n->sign=sign;
  242.     dI(&help);
  243.     return count;
  244. }        /* atoI */
  245.